package tuplestore

import (
	"bytes"
	"compress/gzip"
	"encoding/binary"
	"errors"
	"fmt"
	"io"
	"math"
	"time"
)

var (
	ErrCompressionFailed   = errors.New("compression failed")
	ErrDecompressionFailed = errors.New("decompression failed")
)

// EncodingType 编码类型枚举
type EncodingType byte

const (
	EncodingRaw               EncodingType = iota
	EncodingDictionary                     // 字典编码：将值替换为字典索引
	EncodingRLE                            // 游程编码：适用于重复值
	EncodingDelta                          // 增量编码：存储与前值的差异
	EncodingBitPacking                     // 位打包：对小整数使用较少位
	EncodingByteAligned                    // 字节对齐：为不同值使用最少字节
	EncodingPrefixCompression              // 前缀压缩：用于字符串
	EncodingFrequencyEncoding              // 频率编码：不同长度编码不同值
)

// CompressedColumn 表示单个压缩列
type CompressedColumn struct {
	ElementIndex int         // 对应元素索引
	DataType     ElementType // 数据类型
	// 压缩元数据
	ValueCount int    // 值的数量
	NullCount  int    // 空值数量
	NullBitmap []byte // 空值位图
	// 压缩方法与数据
	EncodingType EncodingType // 使用的编码类型
	EncodedData  []byte       // 压缩后的字节数据
	// 用于字典编码的字典
	Dictionary []interface{}          // 值字典（仅用于字典编码）
	DictMap    map[interface{}]uint32 // 值到索引的映射
}

// ColumnCompressor 列压缩接口
type ColumnCompressor interface {
	CompressColumn(values []interface{}, dataType ElementType) (*CompressedColumn, error)
	DecompressColumn(col *CompressedColumn) ([]interface{}, error)
}

// BitWriter 用于位级别的写入操作
type BitWriter struct {
	data       []byte
	bitPos     uint
	bitsPerVal uint
}

// NewBitWriter 创建新的位写入器
func NewBitWriter(bitsPerVal uint) *BitWriter {
	initialCapacity := 1024 // 初始分配1KB
	return &BitWriter{
		data:       make([]byte, 0, initialCapacity),
		bitPos:     0,
		bitsPerVal: bitsPerVal,
	}
}

// Write 写入一个值
func (bw *BitWriter) Write(val uint32) {
	bytePos := bw.bitPos / 8
	bitOffset := bw.bitPos % 8

	// 确保data有足够空间
	needed := bytePos + 8 // 最多需要8个字节
	for uint(len(bw.data)) <= needed {
		bw.data = append(bw.data, 0)
	}

	// 写入位
	remaining := bw.bitsPerVal
	for remaining > 0 {
		bitsToWrite := uint(8) - bitOffset
		if remaining < bitsToWrite {
			bitsToWrite = remaining
		}

		// 创建掩码并写入
		mask := (uint32(1) << bitsToWrite) - 1
		bits := (val & mask) << bitOffset
		byteIndex := bytePos
		if byteIndex < uint(len(bw.data)) {
			bw.data[byteIndex] |= byte(bits)
		}

		val >>= bitsToWrite
		remaining -= bitsToWrite
		bitOffset = 0
		bytePos++
		bw.bitPos += bitsToWrite
	}
}

// Bytes 返回字节数据
func (bw *BitWriter) Bytes() []byte {
	// 计算多少字节被使用
	bytesUsed := (bw.bitPos + 7) / 8
	return bw.data[:bytesUsed]
}

// BitReader 用于位级别的读取操作
type BitReader struct {
	data       []byte
	bitPos     uint
	bitsPerVal uint
}

// NewBitReader 创建新的位读取器
func NewBitReader(data []byte, bitsPerVal uint) *BitReader {
	return &BitReader{
		data:       data,
		bitPos:     0,
		bitsPerVal: bitsPerVal,
	}
}

// Read 读取一个值
func (br *BitReader) Read() (uint32, error) {
	if br.bitPos/8 >= uint(len(br.data)) {
		return 0, io.EOF
	}

	val := uint32(0)
	remaining := br.bitsPerVal
	bytePos := br.bitPos / 8
	bitOffset := br.bitPos % 8

	valBitPos := uint(0)
	for remaining > 0 {
		if bytePos >= uint(len(br.data)) {
			return 0, io.EOF
		}

		bitsToRead := uint(8) - bitOffset
		if remaining < bitsToRead {
			bitsToRead = remaining
		}

		// 读取位
		mask := byte((1 << bitsToRead) - 1)
		bits := (br.data[bytePos] >> bitOffset) & mask
		val |= uint32(bits) << valBitPos

		valBitPos += bitsToRead
		remaining -= bitsToRead
		bitOffset = 0
		bytePos++
		br.bitPos += bitsToRead
	}

	return val, nil
}

// 字典编码压缩
func encodeDictionary(values []interface{}, dataType ElementType) (*CompressedColumn, error) {
	col := &CompressedColumn{
		EncodingType: EncodingDictionary,
		ValueCount:   len(values),
		DataType:     dataType,
	}

	if len(values) == 0 {
		return col, nil
	}

	// 构建空值位图
	nullBitmap := make([]byte, (len(values)+7)/8)
	nullCount := 0

	// 1. 构建唯一值字典，同时处理空值
	valueset := make(map[interface{}]struct{})
	for i, v := range values {
		if v == nil {
			nullCount++
			// 设置空值位图
			byteIdx := i / 8
			bitIdx := i % 8
			nullBitmap[byteIdx] |= (1 << bitIdx)
		} else {
			valueset[v] = struct{}{}
		}
	}

	// 2. 为每个唯一值分配索引
	col.Dictionary = make([]interface{}, 0, len(valueset))
	col.DictMap = make(map[interface{}]uint32)
	for v := range valueset {
		idx := uint32(len(col.Dictionary))
		col.Dictionary = append(col.Dictionary, v)
		col.DictMap[v] = idx
	}

	// 设置空值相关字段
	col.NullCount = nullCount
	col.NullBitmap = nullBitmap

	// 3. 确定索引编码需要的位数
	dictSize := len(col.Dictionary)
	bitsPerIndex := 0
	if dictSize <= 1 {
		bitsPerIndex = 1
	} else {
		bitsPerIndex = int(math.Ceil(math.Log2(float64(dictSize))))
	}

	// 4. 将值转换为索引并位打包
	writer := NewBitWriter(uint(bitsPerIndex))
	for _, v := range values {
		if v != nil {
			writer.Write(col.DictMap[v])
		} else {
			// 对于空值，可以写入0（任意值都可以，因为我们有空值位图）
			writer.Write(0)
		}
	}
	col.EncodedData = writer.Bytes()

	return col, nil
}

// 解码字典编码数据
func decodeDictionary(col *CompressedColumn) ([]interface{}, error) {
	if col.EncodingType != EncodingDictionary {
		return nil, errors.New("错误的编码类型")
	}

	values := make([]interface{}, col.ValueCount)

	// 如果列为空，直接返回
	if col.ValueCount == 0 {
		return values, nil
	}

	// 计算每个索引需要的位数
	dictSize := len(col.Dictionary)
	bitsPerIndex := 0
	if dictSize <= 1 {
		bitsPerIndex = 1
	} else {
		bitsPerIndex = int(math.Ceil(math.Log2(float64(dictSize))))
	}

	// 读取索引并转换回原始值
	reader := NewBitReader(col.EncodedData, uint(bitsPerIndex))
	for i := 0; i < col.ValueCount; i++ {
		// 检查是否为空值
		byteIdx := i / 8
		bitIdx := i % 8
		isNull := byteIdx < len(col.NullBitmap) && (col.NullBitmap[byteIdx]&(1<<bitIdx)) != 0

		if isNull {
			values[i] = nil
			// 仍然需要读取一个值，但我们会忽略它
			_, err := reader.Read()
			if err != nil {
				return nil, err
			}
		} else {
			idx, err := reader.Read()
			if err != nil {
				return nil, err
			}
			if int(idx) >= len(col.Dictionary) {
				return nil, errors.New("字典索引超出范围")
			}
			values[i] = col.Dictionary[idx]
		}
	}

	return values, nil
}

// 增量编码压缩（适用于整数类型）
func encodeDelta(values []int64) (*CompressedColumn, error) {
	col := &CompressedColumn{
		EncodingType: EncodingDelta,
		ValueCount:   len(values),
		DataType:     TypeInt64,
	}

	if len(values) == 0 {
		return col, nil
	}

	// 1. 计算基值和增量值
	baseValue := values[0]
	deltas := make([]int64, len(values))
	deltas[0] = 0 // 第一个值的增量为 0
	for i := 1; i < len(values); i++ {
		deltas[i] = values[i] - values[i-1]
	}

	// 2. 将基值存储为元数据
	baseValueBytes := make([]byte, 8)
	binary.LittleEndian.PutUint64(baseValueBytes, uint64(baseValue))

	// 3. 为增量值使用可变长度编码
	var varintBuffer bytes.Buffer
	for _, delta := range deltas {
		// 使用 zigzag 编码处理负数
		zigzagDelta := (delta << 1) ^ (delta >> 63)
		// 写入可变长度整数
		for zigzagDelta >= 128 {
			varintBuffer.WriteByte(byte(zigzagDelta) | 128)
			zigzagDelta >>= 7
		}
		varintBuffer.WriteByte(byte(zigzagDelta))
	}

	// 4. 组合基值和增量
	col.EncodedData = append(baseValueBytes, varintBuffer.Bytes()...)
	return col, nil
}

// 解码增量编码数据
func decodeDelta(col *CompressedColumn) ([]int64, error) {
	if col.EncodingType != EncodingDelta {
		return nil, errors.New("错误的编码类型")
	}

	values := make([]int64, col.ValueCount)

	if col.ValueCount == 0 || len(col.EncodedData) < 8 {
		return values, nil
	}

	// 1. 读取基值
	baseValue := int64(binary.LittleEndian.Uint64(col.EncodedData[:8]))

	// 2. 读取增量值
	values[0] = baseValue
	pos := 8 // 基值后的位置

	for i := 1; i < col.ValueCount && pos < len(col.EncodedData); i++ {
		// 解码可变长度整数
		result := uint64(0)
		shift := uint(0)

		for pos < len(col.EncodedData) {
			b := col.EncodedData[pos]
			pos++

			result |= uint64(b&127) << shift
			shift += 7

			if b < 128 {
				break
			}
		}

		// 解码 zigzag 编码
		zigzagValue := result
		delta := int64((zigzagValue >> 1) ^ -(zigzagValue & 1))

		// 应用增量
		values[i] = values[i-1] + delta
	}

	return values, nil
}

// 游程编码压缩
func encodeRLE(values []interface{}, dataType ElementType) (*CompressedColumn, error) {
	col := &CompressedColumn{
		EncodingType: EncodingRLE,
		ValueCount:   len(values),
		DataType:     dataType,
	}

	if len(values) == 0 {
		return col, nil
	}

	// 压缩策略：(重复次数, 值) 对
	var buffer bytes.Buffer
	currentValue := values[0]
	runLength := 1

	// 记录空值
	nullBitmap := make([]byte, (len(values)+7)/8)
	nullCount := 0

	if currentValue == nil {
		nullCount++
		nullBitmap[0] |= 1 // 设置第一个值为空
	}

	for i := 1; i < len(values); i++ {
		if values[i] == nil {
			nullCount++
			// 设置空值位图
			byteIdx := i / 8
			bitIdx := i % 8
			nullBitmap[byteIdx] |= (1 << bitIdx)
		}

		// 比较值是否相等（nil和nil也算相等）
		valuesEqual := (values[i] == nil && currentValue == nil) ||
			(values[i] != nil && currentValue != nil && values[i] == currentValue)

		if valuesEqual {
			runLength++
		} else {
			// 写入 (runLength, value) 对
			writeRunLength(&buffer, runLength)
			writeValue(&buffer, currentValue, dataType)
			// 重置当前值和计数
			currentValue = values[i]
			runLength = 1
		}
	}
	// 处理最后一组
	writeRunLength(&buffer, runLength)
	writeValue(&buffer, currentValue, dataType)

	col.EncodedData = buffer.Bytes()
	col.NullCount = nullCount
	col.NullBitmap = nullBitmap

	return col, nil
}

// 使用可变长度编码写入重复计数
func writeRunLength(buffer *bytes.Buffer, length int) {
	for length >= 128 {
		buffer.WriteByte(byte(length&127) | 128)
		length >>= 7
	}
	buffer.WriteByte(byte(length))
}

// 读取重复计数
func readRunLength(data []byte, pos *int) (int, error) {
	if *pos >= len(data) {
		return 0, io.EOF
	}

	result := 0
	shift := 0

	for *pos < len(data) {
		b := data[*pos]
		*pos++

		result |= int(b&127) << shift
		shift += 7

		if b < 128 {
			break
		}
	}

	return result, nil
}

// 写入值 (根据类型使用不同编码)
func writeValue(buffer *bytes.Buffer, value interface{}, dataType ElementType) {
	if value == nil {
		// 对于空值，写入标记
		buffer.WriteByte(255) // 使用特殊标记表示NULL
		return
	}

	// 非空值标记
	buffer.WriteByte(0)

	switch dataType {
	case TypeInt32:
		binary.Write(buffer, binary.LittleEndian, value.(int32))
	case TypeInt64:
		binary.Write(buffer, binary.LittleEndian, value.(int64))
	case TypeFloat32:
		binary.Write(buffer, binary.LittleEndian, value.(float32))
	case TypeFloat64:
		binary.Write(buffer, binary.LittleEndian, value.(float64))
	case TypeBool:
		if value.(bool) {
			buffer.WriteByte(1)
		} else {
			buffer.WriteByte(0)
		}
	case TypeString:
		str := value.(string)
		writeRunLength(buffer, len(str))
		buffer.WriteString(str)
	case TypeTime:
		t := value.(time.Time)
		binary.Write(buffer, binary.LittleEndian, t.UnixNano())
	}
}

// 读取值
func readValue(data []byte, pos *int, dataType ElementType) (interface{}, error) {
	if *pos >= len(data) {
		return nil, io.EOF
	}

	// 检查是否为空值
	nullMarker := data[*pos]
	*pos++

	if nullMarker == 255 {
		return nil, nil // NULL值
	}

	switch dataType {
	case TypeInt32:
		if *pos+4 > len(data) {
			return nil, io.EOF
		}
		val := int32(binary.LittleEndian.Uint32(data[*pos : *pos+4]))
		*pos += 4
		return val, nil
	case TypeInt64:
		if *pos+8 > len(data) {
			return nil, io.EOF
		}
		val := int64(binary.LittleEndian.Uint64(data[*pos : *pos+8]))
		*pos += 8
		return val, nil
	case TypeFloat32:
		if *pos+4 > len(data) {
			return nil, io.EOF
		}
		bits := binary.LittleEndian.Uint32(data[*pos : *pos+4])
		*pos += 4
		return math.Float32frombits(bits), nil
	case TypeFloat64:
		if *pos+8 > len(data) {
			return nil, io.EOF
		}
		bits := binary.LittleEndian.Uint64(data[*pos : *pos+8])
		*pos += 8
		return math.Float64frombits(bits), nil
	case TypeBool:
		if *pos >= len(data) {
			return nil, io.EOF
		}
		val := data[*pos] != 0
		*pos++
		return val, nil
	case TypeString:
		length, err := readRunLength(data, pos)
		if err != nil {
			return nil, err
		}
		if *pos+length > len(data) {
			return nil, io.EOF
		}
		str := string(data[*pos : *pos+length])
		*pos += length
		return str, nil
	case TypeTime:
		if *pos+8 > len(data) {
			return nil, io.EOF
		}
		nano := int64(binary.LittleEndian.Uint64(data[*pos : *pos+8]))
		*pos += 8
		return time.Unix(0, nano), nil
	default:
		return nil, errors.New("不支持的数据类型")
	}
}

// 解码游程编码数据
func decodeRLE(col *CompressedColumn) ([]interface{}, error) {
	if col.EncodingType != EncodingRLE {
		return nil, errors.New("错误的编码类型")
	}

	values := make([]interface{}, col.ValueCount)

	if col.ValueCount == 0 || len(col.EncodedData) == 0 {
		return values, nil
	}

	pos := 0
	valueIdx := 0

	for pos < len(col.EncodedData) && valueIdx < col.ValueCount {
		// 读取重复次数
		runLength, err := readRunLength(col.EncodedData, &pos)
		if err != nil {
			return nil, err
		}

		// 读取值
		value, err := readValue(col.EncodedData, &pos, col.DataType)
		if err != nil {
			return nil, err
		}

		// 填充值到输出数组
		for i := 0; i < runLength && valueIdx < col.ValueCount; i++ {
			values[valueIdx] = value
			valueIdx++
		}
	}

	// 应用空值位图
	for i := 0; i < col.ValueCount; i++ {
		byteIdx := i / 8
		bitIdx := i % 8
		if byteIdx < len(col.NullBitmap) && (col.NullBitmap[byteIdx]&(1<<bitIdx)) != 0 {
			values[i] = nil
		}
	}

	return values, nil
}

// 选择最佳压缩方法
func chooseCompression(values []interface{}, dataType ElementType) (*CompressedColumn, error) {
	// 检查数据特性
	valueCount := len(values)
	if valueCount == 0 {
		return &CompressedColumn{
			EncodingType: EncodingRaw,
			ValueCount:   0,
			DataType:     dataType,
		}, nil
	}

	// 统计唯一值数量
	uniqueValues := make(map[interface{}]int)
	nullCount := 0

	for _, v := range values {
		if v == nil {
			nullCount++
		} else {
			uniqueValues[v]++
		}
	}

	uniqueCount := len(uniqueValues)

	// 1. 高度重复值，使用RLE
	if float64(uniqueCount)/float64(valueCount) < 0.1 {
		return encodeRLE(values, dataType)
	}

	// 2. 较低基数，使用字典编码
	if float64(uniqueCount)/float64(valueCount) < 0.5 {
		return encodeDictionary(values, dataType)
	}

	// 3. 对于有序整数数据，尝试增量编码
	if dataType == TypeInt32 || dataType == TypeInt64 {
		// 检查是否是有序的
		isSorted := true
		var lastVal int64

		for i, v := range values {
			if v == nil {
				continue // 忽略空值
			}

			var currentVal int64
			if dataType == TypeInt32 {
				currentVal = int64(v.(int32))
			} else {
				currentVal = v.(int64)
			}

			if i > 0 && v != nil && currentVal < lastVal {
				isSorted = false
				break
			}
			lastVal = currentVal
		}

		if isSorted {
			// 转换为int64数组
			int64Values := make([]int64, 0, valueCount-nullCount)
			for _, v := range values {
				if v != nil {
					if dataType == TypeInt32 {
						int64Values = append(int64Values, int64(v.(int32)))
					} else {
						int64Values = append(int64Values, v.(int64))
					}
				}
			}
			return encodeDelta(int64Values)
		}
	}

	// 默认使用字典编码
	return encodeDictionary(values, dataType)
}

// CompressBlock 压缩整个块的数据
func (b *Block) CompressBlock() error {
	b.mu.Lock()
	defer b.mu.Unlock()

	// 如果Schema为空，无法压缩
	if len(b.Schema) == 0 {
		return errors.New("无法压缩：Schema未设置")
	}

	// 检查块中是否有数据需要压缩
	b.MainStore.mu.RLock()
	mainStoreEmpty := len(b.MainStore.tuples) == 0
	b.MainStore.mu.RUnlock()

	b.DeltaStore.mu.RLock()
	deltaStoreEmpty := len(b.DeltaStore.tuples) == 0
	b.DeltaStore.mu.RUnlock()

	if mainStoreEmpty && deltaStoreEmpty {
		return errors.New("无数据可压缩")
	}

	// 遍历每一列，进行压缩
	for elemIndex, elemInfo := range b.Schema {
		// 提取列数据
		values, err := b.decompressColumn(elemIndex, b.Schema)
		if err != nil {
			return fmt.Errorf("提取列数据错误: %w", err)
		}

		if len(values) == 0 {
			continue // 跳过空列
		}

		// 压缩列数据
		compressedCol, err := chooseCompression(values, elemInfo.Type)
		if err != nil {
			return fmt.Errorf("压缩列数据错误: %w", err)
		}

		// 存储压缩后的列
		compressedCol.ElementIndex = elemIndex

		// 添加到块的压缩列存储中
		if b.CompressedColumns == nil {
			b.CompressedColumns = make(map[int]*CompressedColumn)
		}
		b.CompressedColumns[elemIndex] = compressedCol
	}

	// 压缩完成后，如果启用了压缩模式，清理原始数据以释放内存
	if b.useCompression {
		// 主存储中保存列式压缩数据后，清除行式原始数据
		b.MainStore.mu.Lock()
		b.MainStore.tuples = make(map[string]*Tuple) // 清除原始数据
		b.MainStore.mu.Unlock()

		// 也清除增量存储中的数据
		b.DeltaStore.mu.Lock()
		b.DeltaStore.tuples = make(map[string]*Tuple)
		b.DeltaStore.size = 0
		b.DeltaStore.mu.Unlock()
	}

	return nil
}

// DecompressColumnData 解压缩列数据
func (b *Block) DecompressColumnData(elemIndex int) ([]interface{}, error) {
	// 检查是否有压缩的列数据
	if b.CompressedColumns == nil {
		return nil, errors.New("没有压缩列数据")
	}

	compressedCol, exists := b.CompressedColumns[elemIndex]
	if !exists {
		return nil, errors.New("指定列未压缩")
	}

	// 根据编码类型解压缩
	switch compressedCol.EncodingType {
	case EncodingDictionary:
		return decodeDictionary(compressedCol)
	case EncodingRLE:
		return decodeRLE(compressedCol)
	case EncodingDelta:
		int64Values, err := decodeDelta(compressedCol)
		if err != nil {
			return nil, err
		}

		// 转换回原始类型
		values := make([]interface{}, len(int64Values))
		for i, v := range int64Values {
			if compressedCol.DataType == TypeInt32 {
				values[i] = int32(v)
			} else {
				values[i] = v
			}
		}
		return values, nil
	default:
		return nil, errors.New("不支持的编码类型")
	}
}

// compressTuple 压缩元组
func (b *Block) compressTuple(tuple *Tuple) error {
	if tuple == nil {
		return ErrNilTuple
	}

	var buf bytes.Buffer
	gw := gzip.NewWriter(&buf)

	// 写入元组数据
	if _, err := gw.Write(tuple.Data); err != nil {
		return ErrCompressionFailed
	}

	if err := gw.Close(); err != nil {
		return ErrCompressionFailed
	}

	// 更新元组数据为压缩后的数据
	tuple.Data = buf.Bytes()
	return nil
}

// decompressTuple 解压缩元组
func (b *Block) decompressTuple(id string) (*Tuple, error) {
	// 先从增量存储中查找
	if tuple := b.DeltaStore.findTuple(id); tuple != nil {
		return b.decompressTupleData(tuple)
	}

	// 再从主存储中查找
	if tuple := b.MainStore.findTuple(id); tuple != nil {
		return b.decompressTupleData(tuple)
	}

	return nil, ErrNotFound
}

// decompressTupleData 解压缩元组数据
func (b *Block) decompressTupleData(tuple *Tuple) (*Tuple, error) {
	if tuple == nil {
		return nil, ErrNilTuple
	}

	gr, err := gzip.NewReader(bytes.NewReader(tuple.Data))
	if err != nil {
		return nil, ErrDecompressionFailed
	}
	defer gr.Close()

	decompressed, err := io.ReadAll(gr)
	if err != nil {
		return nil, ErrDecompressionFailed
	}

	// 创建新的元组，避免修改原始数据
	return &Tuple{
		ID:        tuple.ID,
		Data:      decompressed,
		Timestamp: tuple.Timestamp,
		Schema:    tuple.Schema,
	}, nil
}

// decompressColumn 解压缩列
func (b *Block) decompressColumn(elemIndex int, schema []ElementInfo) ([]interface{}, error) {
	if elemIndex >= len(schema) {
		return nil, errors.New("invalid element index")
	}

	results := make([]interface{}, 0)

	// 从增量存储中提取
	b.DeltaStore.mu.RLock()
	deltaValues := make([]interface{}, 0, len(b.DeltaStore.tuples))
	for _, tuple := range b.DeltaStore.tuples {
		if tuple.Schema == nil {
			tuple.Schema = schema // 确保元组有Schema
		}
		if val, err := extractElement(tuple.Data, elemIndex, tuple.Schema); err == nil {
			deltaValues = append(deltaValues, val)
		}
	}
	b.DeltaStore.mu.RUnlock()

	// 从主存储中提取
	b.MainStore.mu.RLock()
	mainValues := make([]interface{}, 0, len(b.MainStore.tuples))
	for _, tuple := range b.MainStore.tuples {
		if tuple.Schema == nil {
			tuple.Schema = schema // 确保元组有Schema
		}
		if val, err := extractElement(tuple.Data, elemIndex, tuple.Schema); err == nil {
			mainValues = append(mainValues, val)
		}
	}
	b.MainStore.mu.RUnlock()

	// 合并结果
	results = append(results, deltaValues...)
	results = append(results, mainValues...)

	if len(results) == 0 {
		return nil, fmt.Errorf("列 %d 未找到数据", elemIndex)
	}

	return results, nil
}

// decompressTupleAt 解压缩指定位置的元组
func (b *Block) decompressTupleAt(index int) (*Tuple, error) {
	// TODO: 实现指定位置元组解压缩逻辑
	// 目前简单返回nil
	return nil, ErrDecompressionFailed
}

// getTupleID 获取指定位置的元组ID
func (b *Block) getTupleID(index int) string {
	b.mu.RLock()
	defer b.mu.RUnlock()

	// 先检查增量存储
	deltaLen := len(b.DeltaStore.tuples)
	if index < deltaLen {
		i := 0
		for _, tuple := range b.DeltaStore.tuples {
			if i == index {
				return tuple.ID
			}
			i++
		}
	}

	// 再检查主存储
	mainIndex := index - deltaLen
	if mainIndex >= 0 {
		i := 0
		for _, tuple := range b.MainStore.tuples {
			if i == mainIndex {
				return tuple.ID
			}
			i++
		}
	}

	return ""
}

// isModified 检查元组是否被修改
func (ds *DeltaStore) isModified(id string) bool {
	ds.mu.Lock()
	defer ds.mu.Unlock()
	_, exists := ds.tuples[id]
	return exists
}

// 压缩相关辅助函数
func compressInt32(value int32) []byte {
	buf := make([]byte, 4)
	binary.LittleEndian.PutUint32(buf, uint32(value))
	return buf
}

func decompressInt32(data []byte) int32 {
	return int32(binary.LittleEndian.Uint32(data))
}

func compressString(value string) []byte {
	return []byte(value)
}

func decompressString(data []byte) string {
	return string(data)
}

// 以下是测试专用函数，用于暴露内部压缩算法

// EncodeDictionaryTest 测试用的字典编码函数
func EncodeDictionaryTest(values []interface{}, dataType ElementType) (*CompressedColumn, error) {
	return encodeDictionary(values, dataType)
}

// DecodeDictionaryTest 测试用的字典解码函数
func DecodeDictionaryTest(col *CompressedColumn) ([]interface{}, error) {
	return decodeDictionary(col)
}

// EncodeRLETest 测试用的RLE编码函数
func EncodeRLETest(values []interface{}, dataType ElementType) (*CompressedColumn, error) {
	return encodeRLE(values, dataType)
}

// DecodeRLETest 测试用的RLE解码函数
func DecodeRLETest(col *CompressedColumn) ([]interface{}, error) {
	return decodeRLE(col)
}

// EncodeDeltaTest 测试用的增量编码函数
func EncodeDeltaTest(values []int64) (*CompressedColumn, error) {
	return encodeDelta(values)
}

// DecodeDeltaTest 测试用的增量解码函数
func DecodeDeltaTest(col *CompressedColumn) ([]int64, error) {
	return decodeDelta(col)
}

// ExtractElementFromTest 测试用的元素提取函数
func ExtractElementFromTest(data []byte, index int, schema []ElementInfo) (interface{}, error) {
	return extractElement(data, index, schema)
}
